EnigmA Amiga Run 1997 May/EnigmA AMIGA RUN 18 (1997)(G.R. Edizioni)(IT)[!][issue 1997-05][EAR-CD II].iso/earcd/misc/emu/arosdev.lha/AROS/workbench/c/dir.c

C/C++ Source or Header | 1997-01-27 | 5KB | 267 lines

/*
    (C) 1995-96 AROS - The Amiga Replacement OS
    $Id: dir.c,v 1.12 1997/01/27 00:22:36 ldp Exp $

    Desc: Dir CLI command
    Lang: english
*/
#include <exec/memory.h>
#include <proto/exec.h>
#include <dos/dos.h>
#include <dos/exall.h>
#include <dos/datetime.h>
#include <proto/dos.h>
#include <proto/utility.h>
#include <utility/tagitem.h>
#include <utility/utility.h>
#include <string.h>
#include <stdlib.h>
#include <memory.h>
#include <aros/debug.h>

static const char version[] = "$VER: Dir 1.9 (4.10.1996)\n";

struct UtilityBase *UtilityBase;

struct table
{
    char ** entries;
    int     num, max;
};

char ** files;
int num_files, max_files;
char ** dirs;
int num_dirs, max_dirs;

static int AddEntry (struct table * table, char * entry)
{
    char * dup;

    if (table->num == table->max)
    {
    int new_max = table->max + 128;
    char ** new_entries;

    new_entries = AllocVec (sizeof(char *)*new_max, MEMF_ANY);

    if (!new_entries)
        return 0;

    if (table->num)
    {
        CopyMemQuick (table->entries, new_entries, sizeof(char *)* table->num);
        FreeVec (table->entries);
    }

    table->entries = new_entries;
    table->max = new_max;
    }

    if (!(dup = strdup (entry)) )
    return 0;

    table->entries[table->num ++] = dup;
    return 1;
}

static int compare_strings (const void * s1, const void * s2)
{
    return strcasecmp (*(char **)s1, *(char **)s2);
}

int indent = 0;
static void showline (char * fmt, LONG args[])
{
    int t;

    for (t=0; t<indent; t++)
    VPrintf ("    ", NULL);

    VPrintf (fmt, args);
}

struct
{
    char * dir;
    char * opt;
    ULONG all;
} args = {
    NULL,
    NULL,
    0
};
char path[1024];

static LONG do_dir (void)
{
    BPTR dir;
    LONG loop;
    struct ExAllControl *eac;
    struct ExAllData *ead;
    static UBYTE buffer[4096];
    LONG error=0;
    struct table dirs, files;

    dirs.entries = files.entries = NULL;
    dirs.max = files.max = 0;
    dirs.num = files.num = 0;

    dir=Lock(path,SHARED_LOCK);
    if(dir)
    {
    eac=AllocDosObject(DOS_EXALLCONTROL,NULL);
    if(eac!=NULL)
    {
        int t;
        IPTR argv[3];

        eac->eac_LastKey=0;
        do
        {
        loop=ExAll(dir,(struct ExAllData *)buffer,4096,ED_COMMENT,eac);
        if(!loop&&IoErr()!=ERROR_NO_MORE_ENTRIES)
        {
            error=RETURN_ERROR;
            break;
        }
        if(eac->eac_Entries)
        {
            ead=(struct ExAllData *)buffer;
            do
            {
            if (!AddEntry (ead->ed_Type > 0 ? &dirs : &files, ead->ed_Name))
            {
                loop = 0;
                error=RETURN_ERROR;
                VPrintf ("out of memory\n", NULL);
                break;
            }

            ead=ead->ed_Next;
            }while(ead!=NULL);
        }
        }while(loop);
        FreeDosObject(DOS_EXALLCONTROL,eac);

        if (!error)
        {
        if (dirs.num)
        {
            char * ptr;
            int added_slash = 0;

            indent ++;

            qsort (dirs.entries, dirs.num, sizeof (char *),
            compare_strings);

            ptr = path + strlen (path);

            if (*path && ptr[-1] != ':' && ptr[-1] != '/')
            {
            *ptr ++ = '/';
            *ptr = 0;

            added_slash = 1;
            }

            for (t=0; t<dirs.num; t++)
            {
            argv[0] = (IPTR) dirs.entries[t];

            if (args.all)
            {
                strcpy (ptr, dirs.entries[t]);

                showline ("%-25.s <DIR>\n", argv);
                do_dir ();
            }
            else
                showline ("    %-25.s <DIR>\n", argv);
            }

            if (added_slash)
            ptr[-1] = 0;

            indent --;
        }

        if (files.num)
        {
            qsort (files.entries, files.num, sizeof (char *),
            compare_strings);

            for (t=0; t<files.num; t+=2)
            {
            argv[0] = (IPTR) (files.entries[t]);
            argv[1] = (IPTR) (t+1 < files.num ? files.entries[t+1] : "");
            if (args.all)
                showline ("    %-25.s %-25.s\n", argv);
            else
                showline ("%-25.s %-25.s\n", argv);
            }
        }
        }

        if (dirs.num)
        {
        for (t=0; t<dirs.num; t++)
        {
            free (dirs.entries[t]);
        }

        if (dirs.entries)
            FreeVec (dirs.entries);
        }

        if (files.num)
        {
        for (t=0; t<files.num; t++)
        {
            free (files.entries[t]);
        }

        if (files.entries)
            FreeVec (files.entries);
        }
    }else
    {
        SetIoErr(ERROR_NO_FREE_STORE);
        error=RETURN_ERROR;
    }
    UnLock(dir);
    }

    return error;
}

int main (int argc, char ** argv)
{
    struct RDArgs *rda;
    LONG error=0;

    UtilityBase=(struct UtilityBase *)OpenLibrary(UTILITYNAME,39);

    if (!UtilityBase)
    return RETURN_ERROR;

    rda=ReadArgs("Dir,OPT/K,ALL/S",(IPTR *)&args,NULL);
    if(rda!=NULL)
    {
    strcpy (path, args.dir!=NULL?args.dir:"");

    error = do_dir ();

    FreeArgs(rda);
    }else
    error=RETURN_FAIL;
    if(error)
    PrintFault(IoErr(),"Dir");

    CloseLibrary((struct Library *)UtilityBase);

    return error;
}